// Code generated by MockGen. DO NOT EDIT.
// Source: vizierapi.pb.go

// Package mock_vizierpb is a generated GoMock package.
package mock_vizierpb

import (
	context "context"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	grpc "google.golang.org/grpc"
	metadata "google.golang.org/grpc/metadata"
	vizierpb "px.dev/pixie/src/api/proto/vizierpb"
)

// MockisColumn_ColData is a mock of isColumn_ColData interface.
type MockisColumn_ColData struct {
	ctrl     *gomock.Controller
	recorder *MockisColumn_ColDataMockRecorder
}

// MockisColumn_ColDataMockRecorder is the mock recorder for MockisColumn_ColData.
type MockisColumn_ColDataMockRecorder struct {
	mock *MockisColumn_ColData
}

// NewMockisColumn_ColData creates a new mock instance.
func NewMockisColumn_ColData(ctrl *gomock.Controller) *MockisColumn_ColData {
	mock := &MockisColumn_ColData{ctrl: ctrl}
	mock.recorder = &MockisColumn_ColDataMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockisColumn_ColData) EXPECT() *MockisColumn_ColDataMockRecorder {
	return m.recorder
}

// Equal mocks base method.
func (m *MockisColumn_ColData) Equal(arg0 interface{}) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Equal", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

// Equal indicates an expected call of Equal.
func (mr *MockisColumn_ColDataMockRecorder) Equal(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Equal", reflect.TypeOf((*MockisColumn_ColData)(nil).Equal), arg0)
}

// MarshalTo mocks base method.
func (m *MockisColumn_ColData) MarshalTo(arg0 []byte) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MarshalTo", arg0)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MarshalTo indicates an expected call of MarshalTo.
func (mr *MockisColumn_ColDataMockRecorder) MarshalTo(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarshalTo", reflect.TypeOf((*MockisColumn_ColData)(nil).MarshalTo), arg0)
}

// Size mocks base method.
func (m *MockisColumn_ColData) Size() int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Size")
	ret0, _ := ret[0].(int)
	return ret0
}

// Size indicates an expected call of Size.
func (mr *MockisColumn_ColDataMockRecorder) Size() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Size", reflect.TypeOf((*MockisColumn_ColData)(nil).Size))
}

// isColumn_ColData mocks base method.
func (m *MockisColumn_ColData) isColumn_ColData() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "isColumn_ColData")
}

// isColumn_ColData indicates an expected call of isColumn_ColData.
func (mr *MockisColumn_ColDataMockRecorder) isColumn_ColData() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "isColumn_ColData", reflect.TypeOf((*MockisColumn_ColData)(nil).isColumn_ColData))
}

// MockisErrorDetails_Error is a mock of isErrorDetails_Error interface.
type MockisErrorDetails_Error struct {
	ctrl     *gomock.Controller
	recorder *MockisErrorDetails_ErrorMockRecorder
}

// MockisErrorDetails_ErrorMockRecorder is the mock recorder for MockisErrorDetails_Error.
type MockisErrorDetails_ErrorMockRecorder struct {
	mock *MockisErrorDetails_Error
}

// NewMockisErrorDetails_Error creates a new mock instance.
func NewMockisErrorDetails_Error(ctrl *gomock.Controller) *MockisErrorDetails_Error {
	mock := &MockisErrorDetails_Error{ctrl: ctrl}
	mock.recorder = &MockisErrorDetails_ErrorMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockisErrorDetails_Error) EXPECT() *MockisErrorDetails_ErrorMockRecorder {
	return m.recorder
}

// Equal mocks base method.
func (m *MockisErrorDetails_Error) Equal(arg0 interface{}) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Equal", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

// Equal indicates an expected call of Equal.
func (mr *MockisErrorDetails_ErrorMockRecorder) Equal(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Equal", reflect.TypeOf((*MockisErrorDetails_Error)(nil).Equal), arg0)
}

// MarshalTo mocks base method.
func (m *MockisErrorDetails_Error) MarshalTo(arg0 []byte) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MarshalTo", arg0)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MarshalTo indicates an expected call of MarshalTo.
func (mr *MockisErrorDetails_ErrorMockRecorder) MarshalTo(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarshalTo", reflect.TypeOf((*MockisErrorDetails_Error)(nil).MarshalTo), arg0)
}

// Size mocks base method.
func (m *MockisErrorDetails_Error) Size() int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Size")
	ret0, _ := ret[0].(int)
	return ret0
}

// Size indicates an expected call of Size.
func (mr *MockisErrorDetails_ErrorMockRecorder) Size() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Size", reflect.TypeOf((*MockisErrorDetails_Error)(nil).Size))
}

// isErrorDetails_Error mocks base method.
func (m *MockisErrorDetails_Error) isErrorDetails_Error() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "isErrorDetails_Error")
}

// isErrorDetails_Error indicates an expected call of isErrorDetails_Error.
func (mr *MockisErrorDetails_ErrorMockRecorder) isErrorDetails_Error() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "isErrorDetails_Error", reflect.TypeOf((*MockisErrorDetails_Error)(nil).isErrorDetails_Error))
}

// MockisScalarValue_Value is a mock of isScalarValue_Value interface.
type MockisScalarValue_Value struct {
	ctrl     *gomock.Controller
	recorder *MockisScalarValue_ValueMockRecorder
}

// MockisScalarValue_ValueMockRecorder is the mock recorder for MockisScalarValue_Value.
type MockisScalarValue_ValueMockRecorder struct {
	mock *MockisScalarValue_Value
}

// NewMockisScalarValue_Value creates a new mock instance.
func NewMockisScalarValue_Value(ctrl *gomock.Controller) *MockisScalarValue_Value {
	mock := &MockisScalarValue_Value{ctrl: ctrl}
	mock.recorder = &MockisScalarValue_ValueMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockisScalarValue_Value) EXPECT() *MockisScalarValue_ValueMockRecorder {
	return m.recorder
}

// Equal mocks base method.
func (m *MockisScalarValue_Value) Equal(arg0 interface{}) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Equal", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

// Equal indicates an expected call of Equal.
func (mr *MockisScalarValue_ValueMockRecorder) Equal(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Equal", reflect.TypeOf((*MockisScalarValue_Value)(nil).Equal), arg0)
}

// MarshalTo mocks base method.
func (m *MockisScalarValue_Value) MarshalTo(arg0 []byte) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MarshalTo", arg0)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MarshalTo indicates an expected call of MarshalTo.
func (mr *MockisScalarValue_ValueMockRecorder) MarshalTo(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarshalTo", reflect.TypeOf((*MockisScalarValue_Value)(nil).MarshalTo), arg0)
}

// Size mocks base method.
func (m *MockisScalarValue_Value) Size() int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Size")
	ret0, _ := ret[0].(int)
	return ret0
}

// Size indicates an expected call of Size.
func (mr *MockisScalarValue_ValueMockRecorder) Size() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Size", reflect.TypeOf((*MockisScalarValue_Value)(nil).Size))
}

// isScalarValue_Value mocks base method.
func (m *MockisScalarValue_Value) isScalarValue_Value() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "isScalarValue_Value")
}

// isScalarValue_Value indicates an expected call of isScalarValue_Value.
func (mr *MockisScalarValue_ValueMockRecorder) isScalarValue_Value() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "isScalarValue_Value", reflect.TypeOf((*MockisScalarValue_Value)(nil).isScalarValue_Value))
}

// MockisExecuteScriptResponse_Result is a mock of isExecuteScriptResponse_Result interface.
type MockisExecuteScriptResponse_Result struct {
	ctrl     *gomock.Controller
	recorder *MockisExecuteScriptResponse_ResultMockRecorder
}

// MockisExecuteScriptResponse_ResultMockRecorder is the mock recorder for MockisExecuteScriptResponse_Result.
type MockisExecuteScriptResponse_ResultMockRecorder struct {
	mock *MockisExecuteScriptResponse_Result
}

// NewMockisExecuteScriptResponse_Result creates a new mock instance.
func NewMockisExecuteScriptResponse_Result(ctrl *gomock.Controller) *MockisExecuteScriptResponse_Result {
	mock := &MockisExecuteScriptResponse_Result{ctrl: ctrl}
	mock.recorder = &MockisExecuteScriptResponse_ResultMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockisExecuteScriptResponse_Result) EXPECT() *MockisExecuteScriptResponse_ResultMockRecorder {
	return m.recorder
}

// Equal mocks base method.
func (m *MockisExecuteScriptResponse_Result) Equal(arg0 interface{}) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Equal", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}

// Equal indicates an expected call of Equal.
func (mr *MockisExecuteScriptResponse_ResultMockRecorder) Equal(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Equal", reflect.TypeOf((*MockisExecuteScriptResponse_Result)(nil).Equal), arg0)
}

// MarshalTo mocks base method.
func (m *MockisExecuteScriptResponse_Result) MarshalTo(arg0 []byte) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MarshalTo", arg0)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MarshalTo indicates an expected call of MarshalTo.
func (mr *MockisExecuteScriptResponse_ResultMockRecorder) MarshalTo(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarshalTo", reflect.TypeOf((*MockisExecuteScriptResponse_Result)(nil).MarshalTo), arg0)
}

// Size mocks base method.
func (m *MockisExecuteScriptResponse_Result) Size() int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Size")
	ret0, _ := ret[0].(int)
	return ret0
}

// Size indicates an expected call of Size.
func (mr *MockisExecuteScriptResponse_ResultMockRecorder) Size() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Size", reflect.TypeOf((*MockisExecuteScriptResponse_Result)(nil).Size))
}

// isExecuteScriptResponse_Result mocks base method.
func (m *MockisExecuteScriptResponse_Result) isExecuteScriptResponse_Result() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "isExecuteScriptResponse_Result")
}

// isExecuteScriptResponse_Result indicates an expected call of isExecuteScriptResponse_Result.
func (mr *MockisExecuteScriptResponse_ResultMockRecorder) isExecuteScriptResponse_Result() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "isExecuteScriptResponse_Result", reflect.TypeOf((*MockisExecuteScriptResponse_Result)(nil).isExecuteScriptResponse_Result))
}

// MockVizierServiceClient is a mock of VizierServiceClient interface.
type MockVizierServiceClient struct {
	ctrl     *gomock.Controller
	recorder *MockVizierServiceClientMockRecorder
}

// MockVizierServiceClientMockRecorder is the mock recorder for MockVizierServiceClient.
type MockVizierServiceClientMockRecorder struct {
	mock *MockVizierServiceClient
}

// NewMockVizierServiceClient creates a new mock instance.
func NewMockVizierServiceClient(ctrl *gomock.Controller) *MockVizierServiceClient {
	mock := &MockVizierServiceClient{ctrl: ctrl}
	mock.recorder = &MockVizierServiceClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockVizierServiceClient) EXPECT() *MockVizierServiceClientMockRecorder {
	return m.recorder
}

// ExecuteScript mocks base method.
func (m *MockVizierServiceClient) ExecuteScript(ctx context.Context, in *vizierpb.ExecuteScriptRequest, opts ...grpc.CallOption) (vizierpb.VizierService_ExecuteScriptClient, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ExecuteScript", varargs...)
	ret0, _ := ret[0].(vizierpb.VizierService_ExecuteScriptClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ExecuteScript indicates an expected call of ExecuteScript.
func (mr *MockVizierServiceClientMockRecorder) ExecuteScript(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteScript", reflect.TypeOf((*MockVizierServiceClient)(nil).ExecuteScript), varargs...)
}

// GenerateOTelScript mocks base method.
func (m *MockVizierServiceClient) GenerateOTelScript(ctx context.Context, in *vizierpb.GenerateOTelScriptRequest, opts ...grpc.CallOption) (*vizierpb.GenerateOTelScriptResponse, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GenerateOTelScript", varargs...)
	ret0, _ := ret[0].(*vizierpb.GenerateOTelScriptResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GenerateOTelScript indicates an expected call of GenerateOTelScript.
func (mr *MockVizierServiceClientMockRecorder) GenerateOTelScript(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateOTelScript", reflect.TypeOf((*MockVizierServiceClient)(nil).GenerateOTelScript), varargs...)
}

// HealthCheck mocks base method.
func (m *MockVizierServiceClient) HealthCheck(ctx context.Context, in *vizierpb.HealthCheckRequest, opts ...grpc.CallOption) (vizierpb.VizierService_HealthCheckClient, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HealthCheck", varargs...)
	ret0, _ := ret[0].(vizierpb.VizierService_HealthCheckClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HealthCheck indicates an expected call of HealthCheck.
func (mr *MockVizierServiceClientMockRecorder) HealthCheck(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HealthCheck", reflect.TypeOf((*MockVizierServiceClient)(nil).HealthCheck), varargs...)
}

// MockVizierService_ExecuteScriptClient is a mock of VizierService_ExecuteScriptClient interface.
type MockVizierService_ExecuteScriptClient struct {
	ctrl     *gomock.Controller
	recorder *MockVizierService_ExecuteScriptClientMockRecorder
}

// MockVizierService_ExecuteScriptClientMockRecorder is the mock recorder for MockVizierService_ExecuteScriptClient.
type MockVizierService_ExecuteScriptClientMockRecorder struct {
	mock *MockVizierService_ExecuteScriptClient
}

// NewMockVizierService_ExecuteScriptClient creates a new mock instance.
func NewMockVizierService_ExecuteScriptClient(ctrl *gomock.Controller) *MockVizierService_ExecuteScriptClient {
	mock := &MockVizierService_ExecuteScriptClient{ctrl: ctrl}
	mock.recorder = &MockVizierService_ExecuteScriptClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockVizierService_ExecuteScriptClient) EXPECT() *MockVizierService_ExecuteScriptClientMockRecorder {
	return m.recorder
}

// CloseSend mocks base method.
func (m *MockVizierService_ExecuteScriptClient) CloseSend() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloseSend")
	ret0, _ := ret[0].(error)
	return ret0
}

// CloseSend indicates an expected call of CloseSend.
func (mr *MockVizierService_ExecuteScriptClientMockRecorder) CloseSend() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockVizierService_ExecuteScriptClient)(nil).CloseSend))
}

// Context mocks base method.
func (m *MockVizierService_ExecuteScriptClient) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockVizierService_ExecuteScriptClientMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockVizierService_ExecuteScriptClient)(nil).Context))
}

// Header mocks base method.
func (m *MockVizierService_ExecuteScriptClient) Header() (metadata.MD, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Header")
	ret0, _ := ret[0].(metadata.MD)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Header indicates an expected call of Header.
func (mr *MockVizierService_ExecuteScriptClientMockRecorder) Header() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockVizierService_ExecuteScriptClient)(nil).Header))
}

// Recv mocks base method.
func (m *MockVizierService_ExecuteScriptClient) Recv() (*vizierpb.ExecuteScriptResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*vizierpb.ExecuteScriptResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Recv indicates an expected call of Recv.
func (mr *MockVizierService_ExecuteScriptClientMockRecorder) Recv() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockVizierService_ExecuteScriptClient)(nil).Recv))
}

// RecvMsg mocks base method.
func (m_2 *MockVizierService_ExecuteScriptClient) RecvMsg(m interface{}) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockVizierService_ExecuteScriptClientMockRecorder) RecvMsg(m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockVizierService_ExecuteScriptClient)(nil).RecvMsg), m)
}

// SendMsg mocks base method.
func (m_2 *MockVizierService_ExecuteScriptClient) SendMsg(m interface{}) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockVizierService_ExecuteScriptClientMockRecorder) SendMsg(m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockVizierService_ExecuteScriptClient)(nil).SendMsg), m)
}

// Trailer mocks base method.
func (m *MockVizierService_ExecuteScriptClient) Trailer() metadata.MD {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Trailer")
	ret0, _ := ret[0].(metadata.MD)
	return ret0
}

// Trailer indicates an expected call of Trailer.
func (mr *MockVizierService_ExecuteScriptClientMockRecorder) Trailer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockVizierService_ExecuteScriptClient)(nil).Trailer))
}

// MockVizierService_HealthCheckClient is a mock of VizierService_HealthCheckClient interface.
type MockVizierService_HealthCheckClient struct {
	ctrl     *gomock.Controller
	recorder *MockVizierService_HealthCheckClientMockRecorder
}

// MockVizierService_HealthCheckClientMockRecorder is the mock recorder for MockVizierService_HealthCheckClient.
type MockVizierService_HealthCheckClientMockRecorder struct {
	mock *MockVizierService_HealthCheckClient
}

// NewMockVizierService_HealthCheckClient creates a new mock instance.
func NewMockVizierService_HealthCheckClient(ctrl *gomock.Controller) *MockVizierService_HealthCheckClient {
	mock := &MockVizierService_HealthCheckClient{ctrl: ctrl}
	mock.recorder = &MockVizierService_HealthCheckClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockVizierService_HealthCheckClient) EXPECT() *MockVizierService_HealthCheckClientMockRecorder {
	return m.recorder
}

// CloseSend mocks base method.
func (m *MockVizierService_HealthCheckClient) CloseSend() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloseSend")
	ret0, _ := ret[0].(error)
	return ret0
}

// CloseSend indicates an expected call of CloseSend.
func (mr *MockVizierService_HealthCheckClientMockRecorder) CloseSend() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockVizierService_HealthCheckClient)(nil).CloseSend))
}

// Context mocks base method.
func (m *MockVizierService_HealthCheckClient) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockVizierService_HealthCheckClientMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockVizierService_HealthCheckClient)(nil).Context))
}

// Header mocks base method.
func (m *MockVizierService_HealthCheckClient) Header() (metadata.MD, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Header")
	ret0, _ := ret[0].(metadata.MD)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Header indicates an expected call of Header.
func (mr *MockVizierService_HealthCheckClientMockRecorder) Header() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockVizierService_HealthCheckClient)(nil).Header))
}

// Recv mocks base method.
func (m *MockVizierService_HealthCheckClient) Recv() (*vizierpb.HealthCheckResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*vizierpb.HealthCheckResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Recv indicates an expected call of Recv.
func (mr *MockVizierService_HealthCheckClientMockRecorder) Recv() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockVizierService_HealthCheckClient)(nil).Recv))
}

// RecvMsg mocks base method.
func (m_2 *MockVizierService_HealthCheckClient) RecvMsg(m interface{}) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockVizierService_HealthCheckClientMockRecorder) RecvMsg(m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockVizierService_HealthCheckClient)(nil).RecvMsg), m)
}

// SendMsg mocks base method.
func (m_2 *MockVizierService_HealthCheckClient) SendMsg(m interface{}) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockVizierService_HealthCheckClientMockRecorder) SendMsg(m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockVizierService_HealthCheckClient)(nil).SendMsg), m)
}

// Trailer mocks base method.
func (m *MockVizierService_HealthCheckClient) Trailer() metadata.MD {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Trailer")
	ret0, _ := ret[0].(metadata.MD)
	return ret0
}

// Trailer indicates an expected call of Trailer.
func (mr *MockVizierService_HealthCheckClientMockRecorder) Trailer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockVizierService_HealthCheckClient)(nil).Trailer))
}

// MockVizierServiceServer is a mock of VizierServiceServer interface.
type MockVizierServiceServer struct {
	ctrl     *gomock.Controller
	recorder *MockVizierServiceServerMockRecorder
}

// MockVizierServiceServerMockRecorder is the mock recorder for MockVizierServiceServer.
type MockVizierServiceServerMockRecorder struct {
	mock *MockVizierServiceServer
}

// NewMockVizierServiceServer creates a new mock instance.
func NewMockVizierServiceServer(ctrl *gomock.Controller) *MockVizierServiceServer {
	mock := &MockVizierServiceServer{ctrl: ctrl}
	mock.recorder = &MockVizierServiceServerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockVizierServiceServer) EXPECT() *MockVizierServiceServerMockRecorder {
	return m.recorder
}

// ExecuteScript mocks base method.
func (m *MockVizierServiceServer) ExecuteScript(arg0 *vizierpb.ExecuteScriptRequest, arg1 vizierpb.VizierService_ExecuteScriptServer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExecuteScript", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// ExecuteScript indicates an expected call of ExecuteScript.
func (mr *MockVizierServiceServerMockRecorder) ExecuteScript(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteScript", reflect.TypeOf((*MockVizierServiceServer)(nil).ExecuteScript), arg0, arg1)
}

// GenerateOTelScript mocks base method.
func (m *MockVizierServiceServer) GenerateOTelScript(arg0 context.Context, arg1 *vizierpb.GenerateOTelScriptRequest) (*vizierpb.GenerateOTelScriptResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GenerateOTelScript", arg0, arg1)
	ret0, _ := ret[0].(*vizierpb.GenerateOTelScriptResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GenerateOTelScript indicates an expected call of GenerateOTelScript.
func (mr *MockVizierServiceServerMockRecorder) GenerateOTelScript(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateOTelScript", reflect.TypeOf((*MockVizierServiceServer)(nil).GenerateOTelScript), arg0, arg1)
}

// HealthCheck mocks base method.
func (m *MockVizierServiceServer) HealthCheck(arg0 *vizierpb.HealthCheckRequest, arg1 vizierpb.VizierService_HealthCheckServer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HealthCheck", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// HealthCheck indicates an expected call of HealthCheck.
func (mr *MockVizierServiceServerMockRecorder) HealthCheck(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HealthCheck", reflect.TypeOf((*MockVizierServiceServer)(nil).HealthCheck), arg0, arg1)
}

// MockVizierService_ExecuteScriptServer is a mock of VizierService_ExecuteScriptServer interface.
type MockVizierService_ExecuteScriptServer struct {
	ctrl     *gomock.Controller
	recorder *MockVizierService_ExecuteScriptServerMockRecorder
}

// MockVizierService_ExecuteScriptServerMockRecorder is the mock recorder for MockVizierService_ExecuteScriptServer.
type MockVizierService_ExecuteScriptServerMockRecorder struct {
	mock *MockVizierService_ExecuteScriptServer
}

// NewMockVizierService_ExecuteScriptServer creates a new mock instance.
func NewMockVizierService_ExecuteScriptServer(ctrl *gomock.Controller) *MockVizierService_ExecuteScriptServer {
	mock := &MockVizierService_ExecuteScriptServer{ctrl: ctrl}
	mock.recorder = &MockVizierService_ExecuteScriptServerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockVizierService_ExecuteScriptServer) EXPECT() *MockVizierService_ExecuteScriptServerMockRecorder {
	return m.recorder
}

// Context mocks base method.
func (m *MockVizierService_ExecuteScriptServer) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockVizierService_ExecuteScriptServerMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockVizierService_ExecuteScriptServer)(nil).Context))
}

// RecvMsg mocks base method.
func (m_2 *MockVizierService_ExecuteScriptServer) RecvMsg(m interface{}) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockVizierService_ExecuteScriptServerMockRecorder) RecvMsg(m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockVizierService_ExecuteScriptServer)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockVizierService_ExecuteScriptServer) Send(arg0 *vizierpb.ExecuteScriptResponse) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Send indicates an expected call of Send.
func (mr *MockVizierService_ExecuteScriptServerMockRecorder) Send(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockVizierService_ExecuteScriptServer)(nil).Send), arg0)
}

// SendHeader mocks base method.
func (m *MockVizierService_ExecuteScriptServer) SendHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendHeader indicates an expected call of SendHeader.
func (mr *MockVizierService_ExecuteScriptServerMockRecorder) SendHeader(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockVizierService_ExecuteScriptServer)(nil).SendHeader), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockVizierService_ExecuteScriptServer) SendMsg(m interface{}) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockVizierService_ExecuteScriptServerMockRecorder) SendMsg(m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockVizierService_ExecuteScriptServer)(nil).SendMsg), m)
}

// SetHeader mocks base method.
func (m *MockVizierService_ExecuteScriptServer) SetHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetHeader indicates an expected call of SetHeader.
func (mr *MockVizierService_ExecuteScriptServerMockRecorder) SetHeader(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockVizierService_ExecuteScriptServer)(nil).SetHeader), arg0)
}

// SetTrailer mocks base method.
func (m *MockVizierService_ExecuteScriptServer) SetTrailer(arg0 metadata.MD) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTrailer", arg0)
}

// SetTrailer indicates an expected call of SetTrailer.
func (mr *MockVizierService_ExecuteScriptServerMockRecorder) SetTrailer(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockVizierService_ExecuteScriptServer)(nil).SetTrailer), arg0)
}

// MockVizierService_HealthCheckServer is a mock of VizierService_HealthCheckServer interface.
type MockVizierService_HealthCheckServer struct {
	ctrl     *gomock.Controller
	recorder *MockVizierService_HealthCheckServerMockRecorder
}

// MockVizierService_HealthCheckServerMockRecorder is the mock recorder for MockVizierService_HealthCheckServer.
type MockVizierService_HealthCheckServerMockRecorder struct {
	mock *MockVizierService_HealthCheckServer
}

// NewMockVizierService_HealthCheckServer creates a new mock instance.
func NewMockVizierService_HealthCheckServer(ctrl *gomock.Controller) *MockVizierService_HealthCheckServer {
	mock := &MockVizierService_HealthCheckServer{ctrl: ctrl}
	mock.recorder = &MockVizierService_HealthCheckServerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockVizierService_HealthCheckServer) EXPECT() *MockVizierService_HealthCheckServerMockRecorder {
	return m.recorder
}

// Context mocks base method.
func (m *MockVizierService_HealthCheckServer) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockVizierService_HealthCheckServerMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockVizierService_HealthCheckServer)(nil).Context))
}

// RecvMsg mocks base method.
func (m_2 *MockVizierService_HealthCheckServer) RecvMsg(m interface{}) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockVizierService_HealthCheckServerMockRecorder) RecvMsg(m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockVizierService_HealthCheckServer)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockVizierService_HealthCheckServer) Send(arg0 *vizierpb.HealthCheckResponse) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Send indicates an expected call of Send.
func (mr *MockVizierService_HealthCheckServerMockRecorder) Send(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockVizierService_HealthCheckServer)(nil).Send), arg0)
}

// SendHeader mocks base method.
func (m *MockVizierService_HealthCheckServer) SendHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendHeader indicates an expected call of SendHeader.
func (mr *MockVizierService_HealthCheckServerMockRecorder) SendHeader(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockVizierService_HealthCheckServer)(nil).SendHeader), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockVizierService_HealthCheckServer) SendMsg(m interface{}) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockVizierService_HealthCheckServerMockRecorder) SendMsg(m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockVizierService_HealthCheckServer)(nil).SendMsg), m)
}

// SetHeader mocks base method.
func (m *MockVizierService_HealthCheckServer) SetHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetHeader indicates an expected call of SetHeader.
func (mr *MockVizierService_HealthCheckServerMockRecorder) SetHeader(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockVizierService_HealthCheckServer)(nil).SetHeader), arg0)
}

// SetTrailer mocks base method.
func (m *MockVizierService_HealthCheckServer) SetTrailer(arg0 metadata.MD) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTrailer", arg0)
}

// SetTrailer indicates an expected call of SetTrailer.
func (mr *MockVizierService_HealthCheckServerMockRecorder) SetTrailer(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockVizierService_HealthCheckServer)(nil).SetTrailer), arg0)
}

// MockVizierDebugServiceClient is a mock of VizierDebugServiceClient interface.
type MockVizierDebugServiceClient struct {
	ctrl     *gomock.Controller
	recorder *MockVizierDebugServiceClientMockRecorder
}

// MockVizierDebugServiceClientMockRecorder is the mock recorder for MockVizierDebugServiceClient.
type MockVizierDebugServiceClientMockRecorder struct {
	mock *MockVizierDebugServiceClient
}

// NewMockVizierDebugServiceClient creates a new mock instance.
func NewMockVizierDebugServiceClient(ctrl *gomock.Controller) *MockVizierDebugServiceClient {
	mock := &MockVizierDebugServiceClient{ctrl: ctrl}
	mock.recorder = &MockVizierDebugServiceClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockVizierDebugServiceClient) EXPECT() *MockVizierDebugServiceClientMockRecorder {
	return m.recorder
}

// DebugLog mocks base method.
func (m *MockVizierDebugServiceClient) DebugLog(ctx context.Context, in *vizierpb.DebugLogRequest, opts ...grpc.CallOption) (vizierpb.VizierDebugService_DebugLogClient, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DebugLog", varargs...)
	ret0, _ := ret[0].(vizierpb.VizierDebugService_DebugLogClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DebugLog indicates an expected call of DebugLog.
func (mr *MockVizierDebugServiceClientMockRecorder) DebugLog(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DebugLog", reflect.TypeOf((*MockVizierDebugServiceClient)(nil).DebugLog), varargs...)
}

// DebugPods mocks base method.
func (m *MockVizierDebugServiceClient) DebugPods(ctx context.Context, in *vizierpb.DebugPodsRequest, opts ...grpc.CallOption) (vizierpb.VizierDebugService_DebugPodsClient, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DebugPods", varargs...)
	ret0, _ := ret[0].(vizierpb.VizierDebugService_DebugPodsClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DebugPods indicates an expected call of DebugPods.
func (mr *MockVizierDebugServiceClientMockRecorder) DebugPods(ctx, in interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DebugPods", reflect.TypeOf((*MockVizierDebugServiceClient)(nil).DebugPods), varargs...)
}

// MockVizierDebugService_DebugLogClient is a mock of VizierDebugService_DebugLogClient interface.
type MockVizierDebugService_DebugLogClient struct {
	ctrl     *gomock.Controller
	recorder *MockVizierDebugService_DebugLogClientMockRecorder
}

// MockVizierDebugService_DebugLogClientMockRecorder is the mock recorder for MockVizierDebugService_DebugLogClient.
type MockVizierDebugService_DebugLogClientMockRecorder struct {
	mock *MockVizierDebugService_DebugLogClient
}

// NewMockVizierDebugService_DebugLogClient creates a new mock instance.
func NewMockVizierDebugService_DebugLogClient(ctrl *gomock.Controller) *MockVizierDebugService_DebugLogClient {
	mock := &MockVizierDebugService_DebugLogClient{ctrl: ctrl}
	mock.recorder = &MockVizierDebugService_DebugLogClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockVizierDebugService_DebugLogClient) EXPECT() *MockVizierDebugService_DebugLogClientMockRecorder {
	return m.recorder
}

// CloseSend mocks base method.
func (m *MockVizierDebugService_DebugLogClient) CloseSend() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloseSend")
	ret0, _ := ret[0].(error)
	return ret0
}

// CloseSend indicates an expected call of CloseSend.
func (mr *MockVizierDebugService_DebugLogClientMockRecorder) CloseSend() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockVizierDebugService_DebugLogClient)(nil).CloseSend))
}

// Context mocks base method.
func (m *MockVizierDebugService_DebugLogClient) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockVizierDebugService_DebugLogClientMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockVizierDebugService_DebugLogClient)(nil).Context))
}

// Header mocks base method.
func (m *MockVizierDebugService_DebugLogClient) Header() (metadata.MD, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Header")
	ret0, _ := ret[0].(metadata.MD)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Header indicates an expected call of Header.
func (mr *MockVizierDebugService_DebugLogClientMockRecorder) Header() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockVizierDebugService_DebugLogClient)(nil).Header))
}

// Recv mocks base method.
func (m *MockVizierDebugService_DebugLogClient) Recv() (*vizierpb.DebugLogResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*vizierpb.DebugLogResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Recv indicates an expected call of Recv.
func (mr *MockVizierDebugService_DebugLogClientMockRecorder) Recv() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockVizierDebugService_DebugLogClient)(nil).Recv))
}

// RecvMsg mocks base method.
func (m_2 *MockVizierDebugService_DebugLogClient) RecvMsg(m interface{}) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockVizierDebugService_DebugLogClientMockRecorder) RecvMsg(m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockVizierDebugService_DebugLogClient)(nil).RecvMsg), m)
}

// SendMsg mocks base method.
func (m_2 *MockVizierDebugService_DebugLogClient) SendMsg(m interface{}) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockVizierDebugService_DebugLogClientMockRecorder) SendMsg(m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockVizierDebugService_DebugLogClient)(nil).SendMsg), m)
}

// Trailer mocks base method.
func (m *MockVizierDebugService_DebugLogClient) Trailer() metadata.MD {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Trailer")
	ret0, _ := ret[0].(metadata.MD)
	return ret0
}

// Trailer indicates an expected call of Trailer.
func (mr *MockVizierDebugService_DebugLogClientMockRecorder) Trailer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockVizierDebugService_DebugLogClient)(nil).Trailer))
}

// MockVizierDebugService_DebugPodsClient is a mock of VizierDebugService_DebugPodsClient interface.
type MockVizierDebugService_DebugPodsClient struct {
	ctrl     *gomock.Controller
	recorder *MockVizierDebugService_DebugPodsClientMockRecorder
}

// MockVizierDebugService_DebugPodsClientMockRecorder is the mock recorder for MockVizierDebugService_DebugPodsClient.
type MockVizierDebugService_DebugPodsClientMockRecorder struct {
	mock *MockVizierDebugService_DebugPodsClient
}

// NewMockVizierDebugService_DebugPodsClient creates a new mock instance.
func NewMockVizierDebugService_DebugPodsClient(ctrl *gomock.Controller) *MockVizierDebugService_DebugPodsClient {
	mock := &MockVizierDebugService_DebugPodsClient{ctrl: ctrl}
	mock.recorder = &MockVizierDebugService_DebugPodsClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockVizierDebugService_DebugPodsClient) EXPECT() *MockVizierDebugService_DebugPodsClientMockRecorder {
	return m.recorder
}

// CloseSend mocks base method.
func (m *MockVizierDebugService_DebugPodsClient) CloseSend() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloseSend")
	ret0, _ := ret[0].(error)
	return ret0
}

// CloseSend indicates an expected call of CloseSend.
func (mr *MockVizierDebugService_DebugPodsClientMockRecorder) CloseSend() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseSend", reflect.TypeOf((*MockVizierDebugService_DebugPodsClient)(nil).CloseSend))
}

// Context mocks base method.
func (m *MockVizierDebugService_DebugPodsClient) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockVizierDebugService_DebugPodsClientMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockVizierDebugService_DebugPodsClient)(nil).Context))
}

// Header mocks base method.
func (m *MockVizierDebugService_DebugPodsClient) Header() (metadata.MD, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Header")
	ret0, _ := ret[0].(metadata.MD)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Header indicates an expected call of Header.
func (mr *MockVizierDebugService_DebugPodsClientMockRecorder) Header() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockVizierDebugService_DebugPodsClient)(nil).Header))
}

// Recv mocks base method.
func (m *MockVizierDebugService_DebugPodsClient) Recv() (*vizierpb.DebugPodsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Recv")
	ret0, _ := ret[0].(*vizierpb.DebugPodsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Recv indicates an expected call of Recv.
func (mr *MockVizierDebugService_DebugPodsClientMockRecorder) Recv() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Recv", reflect.TypeOf((*MockVizierDebugService_DebugPodsClient)(nil).Recv))
}

// RecvMsg mocks base method.
func (m_2 *MockVizierDebugService_DebugPodsClient) RecvMsg(m interface{}) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockVizierDebugService_DebugPodsClientMockRecorder) RecvMsg(m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockVizierDebugService_DebugPodsClient)(nil).RecvMsg), m)
}

// SendMsg mocks base method.
func (m_2 *MockVizierDebugService_DebugPodsClient) SendMsg(m interface{}) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockVizierDebugService_DebugPodsClientMockRecorder) SendMsg(m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockVizierDebugService_DebugPodsClient)(nil).SendMsg), m)
}

// Trailer mocks base method.
func (m *MockVizierDebugService_DebugPodsClient) Trailer() metadata.MD {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Trailer")
	ret0, _ := ret[0].(metadata.MD)
	return ret0
}

// Trailer indicates an expected call of Trailer.
func (mr *MockVizierDebugService_DebugPodsClientMockRecorder) Trailer() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Trailer", reflect.TypeOf((*MockVizierDebugService_DebugPodsClient)(nil).Trailer))
}

// MockVizierDebugServiceServer is a mock of VizierDebugServiceServer interface.
type MockVizierDebugServiceServer struct {
	ctrl     *gomock.Controller
	recorder *MockVizierDebugServiceServerMockRecorder
}

// MockVizierDebugServiceServerMockRecorder is the mock recorder for MockVizierDebugServiceServer.
type MockVizierDebugServiceServerMockRecorder struct {
	mock *MockVizierDebugServiceServer
}

// NewMockVizierDebugServiceServer creates a new mock instance.
func NewMockVizierDebugServiceServer(ctrl *gomock.Controller) *MockVizierDebugServiceServer {
	mock := &MockVizierDebugServiceServer{ctrl: ctrl}
	mock.recorder = &MockVizierDebugServiceServerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockVizierDebugServiceServer) EXPECT() *MockVizierDebugServiceServerMockRecorder {
	return m.recorder
}

// DebugLog mocks base method.
func (m *MockVizierDebugServiceServer) DebugLog(arg0 *vizierpb.DebugLogRequest, arg1 vizierpb.VizierDebugService_DebugLogServer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DebugLog", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DebugLog indicates an expected call of DebugLog.
func (mr *MockVizierDebugServiceServerMockRecorder) DebugLog(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DebugLog", reflect.TypeOf((*MockVizierDebugServiceServer)(nil).DebugLog), arg0, arg1)
}

// DebugPods mocks base method.
func (m *MockVizierDebugServiceServer) DebugPods(arg0 *vizierpb.DebugPodsRequest, arg1 vizierpb.VizierDebugService_DebugPodsServer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DebugPods", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DebugPods indicates an expected call of DebugPods.
func (mr *MockVizierDebugServiceServerMockRecorder) DebugPods(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DebugPods", reflect.TypeOf((*MockVizierDebugServiceServer)(nil).DebugPods), arg0, arg1)
}

// MockVizierDebugService_DebugLogServer is a mock of VizierDebugService_DebugLogServer interface.
type MockVizierDebugService_DebugLogServer struct {
	ctrl     *gomock.Controller
	recorder *MockVizierDebugService_DebugLogServerMockRecorder
}

// MockVizierDebugService_DebugLogServerMockRecorder is the mock recorder for MockVizierDebugService_DebugLogServer.
type MockVizierDebugService_DebugLogServerMockRecorder struct {
	mock *MockVizierDebugService_DebugLogServer
}

// NewMockVizierDebugService_DebugLogServer creates a new mock instance.
func NewMockVizierDebugService_DebugLogServer(ctrl *gomock.Controller) *MockVizierDebugService_DebugLogServer {
	mock := &MockVizierDebugService_DebugLogServer{ctrl: ctrl}
	mock.recorder = &MockVizierDebugService_DebugLogServerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockVizierDebugService_DebugLogServer) EXPECT() *MockVizierDebugService_DebugLogServerMockRecorder {
	return m.recorder
}

// Context mocks base method.
func (m *MockVizierDebugService_DebugLogServer) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockVizierDebugService_DebugLogServerMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockVizierDebugService_DebugLogServer)(nil).Context))
}

// RecvMsg mocks base method.
func (m_2 *MockVizierDebugService_DebugLogServer) RecvMsg(m interface{}) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockVizierDebugService_DebugLogServerMockRecorder) RecvMsg(m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockVizierDebugService_DebugLogServer)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockVizierDebugService_DebugLogServer) Send(arg0 *vizierpb.DebugLogResponse) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Send indicates an expected call of Send.
func (mr *MockVizierDebugService_DebugLogServerMockRecorder) Send(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockVizierDebugService_DebugLogServer)(nil).Send), arg0)
}

// SendHeader mocks base method.
func (m *MockVizierDebugService_DebugLogServer) SendHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendHeader indicates an expected call of SendHeader.
func (mr *MockVizierDebugService_DebugLogServerMockRecorder) SendHeader(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockVizierDebugService_DebugLogServer)(nil).SendHeader), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockVizierDebugService_DebugLogServer) SendMsg(m interface{}) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockVizierDebugService_DebugLogServerMockRecorder) SendMsg(m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockVizierDebugService_DebugLogServer)(nil).SendMsg), m)
}

// SetHeader mocks base method.
func (m *MockVizierDebugService_DebugLogServer) SetHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetHeader indicates an expected call of SetHeader.
func (mr *MockVizierDebugService_DebugLogServerMockRecorder) SetHeader(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockVizierDebugService_DebugLogServer)(nil).SetHeader), arg0)
}

// SetTrailer mocks base method.
func (m *MockVizierDebugService_DebugLogServer) SetTrailer(arg0 metadata.MD) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTrailer", arg0)
}

// SetTrailer indicates an expected call of SetTrailer.
func (mr *MockVizierDebugService_DebugLogServerMockRecorder) SetTrailer(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockVizierDebugService_DebugLogServer)(nil).SetTrailer), arg0)
}

// MockVizierDebugService_DebugPodsServer is a mock of VizierDebugService_DebugPodsServer interface.
type MockVizierDebugService_DebugPodsServer struct {
	ctrl     *gomock.Controller
	recorder *MockVizierDebugService_DebugPodsServerMockRecorder
}

// MockVizierDebugService_DebugPodsServerMockRecorder is the mock recorder for MockVizierDebugService_DebugPodsServer.
type MockVizierDebugService_DebugPodsServerMockRecorder struct {
	mock *MockVizierDebugService_DebugPodsServer
}

// NewMockVizierDebugService_DebugPodsServer creates a new mock instance.
func NewMockVizierDebugService_DebugPodsServer(ctrl *gomock.Controller) *MockVizierDebugService_DebugPodsServer {
	mock := &MockVizierDebugService_DebugPodsServer{ctrl: ctrl}
	mock.recorder = &MockVizierDebugService_DebugPodsServerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockVizierDebugService_DebugPodsServer) EXPECT() *MockVizierDebugService_DebugPodsServerMockRecorder {
	return m.recorder
}

// Context mocks base method.
func (m *MockVizierDebugService_DebugPodsServer) Context() context.Context {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Context")
	ret0, _ := ret[0].(context.Context)
	return ret0
}

// Context indicates an expected call of Context.
func (mr *MockVizierDebugService_DebugPodsServerMockRecorder) Context() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Context", reflect.TypeOf((*MockVizierDebugService_DebugPodsServer)(nil).Context))
}

// RecvMsg mocks base method.
func (m_2 *MockVizierDebugService_DebugPodsServer) RecvMsg(m interface{}) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "RecvMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockVizierDebugService_DebugPodsServerMockRecorder) RecvMsg(m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockVizierDebugService_DebugPodsServer)(nil).RecvMsg), m)
}

// Send mocks base method.
func (m *MockVizierDebugService_DebugPodsServer) Send(arg0 *vizierpb.DebugPodsResponse) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Send", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// Send indicates an expected call of Send.
func (mr *MockVizierDebugService_DebugPodsServerMockRecorder) Send(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockVizierDebugService_DebugPodsServer)(nil).Send), arg0)
}

// SendHeader mocks base method.
func (m *MockVizierDebugService_DebugPodsServer) SendHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendHeader indicates an expected call of SendHeader.
func (mr *MockVizierDebugService_DebugPodsServerMockRecorder) SendHeader(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendHeader", reflect.TypeOf((*MockVizierDebugService_DebugPodsServer)(nil).SendHeader), arg0)
}

// SendMsg mocks base method.
func (m_2 *MockVizierDebugService_DebugPodsServer) SendMsg(m interface{}) error {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SendMsg", m)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendMsg indicates an expected call of SendMsg.
func (mr *MockVizierDebugService_DebugPodsServerMockRecorder) SendMsg(m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockVizierDebugService_DebugPodsServer)(nil).SendMsg), m)
}

// SetHeader mocks base method.
func (m *MockVizierDebugService_DebugPodsServer) SetHeader(arg0 metadata.MD) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetHeader", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetHeader indicates an expected call of SetHeader.
func (mr *MockVizierDebugService_DebugPodsServerMockRecorder) SetHeader(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHeader", reflect.TypeOf((*MockVizierDebugService_DebugPodsServer)(nil).SetHeader), arg0)
}

// SetTrailer mocks base method.
func (m *MockVizierDebugService_DebugPodsServer) SetTrailer(arg0 metadata.MD) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTrailer", arg0)
}

// SetTrailer indicates an expected call of SetTrailer.
func (mr *MockVizierDebugService_DebugPodsServerMockRecorder) SetTrailer(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTrailer", reflect.TypeOf((*MockVizierDebugService_DebugPodsServer)(nil).SetTrailer), arg0)
}
